Language TutorialLearn YueScript in 15 MinutesOn this pageLearn YueScript in 15 Minutes NoteThis tutorial provides a quick overview of YueScript, a modern alternative to Lua. YueScript inherits Lua's features while introducing syntax sugar and a Python-like coding style. Since YueScript is a dialect of MoonScript, this tutorial is a modified version of "Learn MoonScript in 15 Minutes", and also assumes you have some programming experience and are familiar with Lua, you can refer to the Lua official documentation for learning. YueScript does not use 'do', 'then', or 'end' like Lua would and instead uses an indented syntax, much like Python. -- Two dashes start a comment. Comments can go until the end of the line.-- YueScript transpiled to Lua does not keep comments. 1. Assignment hello = "world"a, b, c = 1, 2, 3hello = 123 -- Overwrites `hello` from above.x = 0x += 10 -- x = x + 10s = "hello "s ..= "world" -- s = s .. "world"b = falseb and= true or false -- b = b and (true or false) 2. Literals and Operators Literals work almost exactly as they would in Lua. Strings can be broken in the middle of a line without requiring a \. some_string = "example" -- local some_string = "exa\nmple" Strings can also have interpolated values, or values that are evaluated and then placed inside of a string. some_string = "This is an #{some_string}" -- Becomes 'This is an exa\nmple'### 2.1. Function LiteralsFunctions are written using arrows:```yuemy_function = -> -- compiles to `function() end`my_function() -- calls an empty function Functions can be called without using parenthesis. Parentheses may still be used to have priority over other functions. func_a = -> print "Hello World!"func_b = -> value = 100 print "The value: #{value}" If a function needs no parameters, it can be called with either () or !. func_a!func_b() Functions can use arguments by preceding the arrow with a list of argument names bound by parentheses. sum = (x, y) -> x + y -- The last expression is returned from the function.print sum(5, 10) Lua has an idiom of sending the first argument to a function as the object, like a 'self' object. Using a fat arrow (=>) instead of a skinny arrow (->) automatically creates a self variable. @x is a shorthand for self.x. func = (num) => @value + num Default arguments can also be used with function literals: a_function = (name = "something", height = 100) -> print "Hello, I am #{name}.\nMy height is #{height}." Because default arguments are calculated in the body of the function when transpiled to Lua, you can reference previous arguments. some_args = (x = 100, y = x + 1000) -> print(x + y) Considerations The minus sign plays two roles, a unary negation operator and a binary subtraction operator. It is recommended to always use spaces between binary operators to avoid the possible collision. a = x - 10 -- a = x - 10b = x-10 -- b = x - 10c = x -y -- c = x(-y)d = x- z -- d = x - z When there is no space between a variable and string literal, the function call takes priority over following expressions: x = func"hello" + 100 -- func("hello") + 100y = func "hello" + 100 -- func("hello" + 100) Arguments to a function can span across multiple lines as long as the arguments are indented. The indentation can be nested as well. my_func 5, -- called as my_func(5, 8, another_func(6, 7, 9, 1, 2), 5, 4) 8, another_func 6, 7, -- called as 9, 1, 2, -- another_func(6, 7, 9, 1, 2) 5, 4 If a function is used at the start of a block, the indentation can be different than the level of indentation used in a block: if func 1, 2, 3, -- called as func(1, 2, 3, "hello", "world") "hello", "world" print "hello" 3. Tables Tables are defined by curly braces, like Lua: some_values = [1, 2, 3, 4] -- better uses `[]` instead of `{}` for array-like tables Tables can use newlines instead of commas. some_other_values = [ 5, 6 7, 8] Assignment is done with : instead of =: profile = { name: "Bill" age: 200 "favorite food": "rice"} Curly braces can be left off for key: value tables. y = type: "dog", legs: 4, tails: 1profile = height: "4 feet", shoe_size: 13, favorite_foods: -- nested table foo: "ice cream", bar: "donuts"my_function dance: "Tango", partner: "none" -- :( forever alone Tables constructed from variables can use the same name as the variables by using : as a prefix operator. hair = "golden"height = 200person = {:hair, :height} Like in Lua, keys can be non-string or non-numeric values by using []. t = [1 + 2]: "hello" "hello world": true -- Can use string literals without `[]`. 3.1. Table Comprehensions List Comprehensions Creates a copy of a list but with all items doubled. Using a star before a variable name or table can be used to iterate through the table's values. items = [1, 2, 3, 4]doubled = [item * 2 for item in *items] Uses when to determine if a value should be included. slice = [item for item in *items[1, 2] when item % 2 == 0] for clauses inside of list comprehensions can be chained. x_coords = [4, 5, 6, 7]y_coords = [9, 2, 3]points = [ [x, y] for x in *x_coords for y in *y_coords] Numeric for loops can also be used in comprehensions: evens = [i for i = 1, 100 when i % 2 == 0] Table Comprehensions are very similar but use { and } and take two values for each iteration. thing = color: "red", name: "thing", width: 123thing_copy = {k, v for k, v in pairs thing} Tables can be "flattened" from key-value pairs in an array by using unpack to return both values, using the first as the key and the second as the value. tuples = [ ["hello", "world"], ["foo", "bar"]]table = {unpack tuple for tuple in *tuples} Slicing can be done to iterate over only a certain section of an array. It uses the * notation for iterating but appends [start, end, step]. The next example also shows that this syntax can be used in a for loop as well as any comprehensions. for item in *points[1, 10, 2] print unpack item Any undesired values can be left off. The second comma is not required if the step is not included. words = ["these", "are", "some", "words"]for word in *words[,3] print word 4. Control Structures have_coins = falseif have_coins print "Got coins"else print "No coins" Use then for single-line if result = if have_coins then "Got coins" else "No coins" unless is the opposite of if unless os.date("%A") == "Monday" print "It is not Monday!" if and unless can be used as expressions is_tall = (name) -> if name == "Rob" then true else falsemessage = "I am #{if is_tall "Rob" then "very tall" else "not so tall"}"print message -- "I am very tall" if, elseif, and unless can evaluate assignment as well as expressions. if x := possibly_nil! -- sets `x` to `possibly_nil()` and evaluates `x` print x Conditionals can be used after a statement as well as before. This is called a "line decorator". is_monday = os.date("%A") == "Monday"print("It IS Monday!") if isMondayprint("It is not Monday..") unless isMonday-- print("It IS Monday!" if isMonday) -- Not a statement, does not work 4.1 Loops for i = 1, 10 print ifor i = 10, 1, -1 do print i -- Use `do` for single-line loops.i = 0while i < 10 continue if i % 2 == 0 -- Continue statement; skip the rest of the loop. print i Loops can be used as a line decorator, just like conditionals print "item: #{item}" for item in *items Using loops as an expression generates an array table. The last statement in the block is coerced into an expression and added to the table. my_numbers = for i = 1, 6 do i -- [1, 2, 3, 4, 5, 6]-- use `continue` to filter out valuesodds = for i in *my_numbers continue if i % 2 == 0 -- acts opposite to `when` in comprehensions! i -- Only added to return table if odd A for loop returns nil when it is the last statement of a function. Use an explicit return to generate a table. print_squared = (t) -> for x in *t do print x * x -- returns `nil`squared = (t) -> return for x in *t do x * x -- returns new table of squares The following does the same as (t) -> [i for i in *t when i % 2 == 0]. But list comprehension generates better code and is more readable! filter_odds = (t) -> return for x in *t if x % 2 == 0 then x else continueevens = filter_odds(my_numbers) -- [2, 4, 6] 4.2 Switch Statements Switch statements are a shorthand way of writing multiple if statements checking against the same value. The value is only evaluated once. name = "Dan"switch name when "Dave" print "You are Dave." when "Dan" print "You are not Dave, but Dan." else print "You are neither Dave nor Dan." Switches can also be used as expressions, as well as compare multiple values. The values can be on the same line as the when clause if they are only one expression. b = 4next_even = switch b when 1 then 2 when 2, 3 then 4 when 4, 5 then 6 else error "I can't count that high! D:" 5. Object Oriented Programming Classes are created using the class keyword followed by an identifier, typically written using CamelCase. Values specific to a class can use @ as the identifier instead of self.value. class Inventory new: => @items = {} add_item: (name) => -- note the use of fat arrow for classes! @items[name] = 0 unless @items[name] @items[name] += 1 The new function inside of a class is special because it is called when an instance of the class is created. Creating an instance of the class is as simple as calling the class as a function. Calling functions inside of the class uses \ to separate the instance from the function it is calling. inv = Inventory!inv\add_item "t-shirt"inv\add_item "pants" Values defined in the class - not the new() function - will be shared across all instances of the class. class Person clothes: [] give_item: (name) => table.insert @clothes, namea = Person!b = Person!a\give_item "pants"b\give_item "shirt"-- prints out both "pants" and "shirt"print item for item in *a.clothes Class instances have a value .__class that are equal to the class object that created the instance. assert b.__class == Person Variables declared in class body the using the = operator are locals, so these "private" variables are only accessible within the current scope. class SomeClass x = 0 reveal: -> x += 1 print xa = SomeClass!b = SomeClass!print a.x -- nila.reveal! -- 1b.reveal! -- 2 5.1 Inheritance The extends keyword can be used to inherit properties and methods from another class. class Backpack extends Inventory size: 10 add_item: (name) => error "backpack is full" if #@items > @size super name -- calls Inventory.add_item with `name`. Because a new method was not added, the new method from Inventory will be used instead. If we did want to use a constructor while still using the constructor from Inventory, we could use the magical super function during new(). When a class extends another, it calls the method __inherited on the parent class (if it exists). It is always called with the parent and the child object. class ParentClass @__inherited: (child) => print "#{@__name} was inherited by #{child.__name}" a_method: (a, b) => print a .. ' ' .. b Will print 'ParentClass was inherited by MyClass' class MyClass extends ParentClass a_method: => super "hello world", "from MyClass!" assert super == ParentClass 6. Scope All values are local by default. The global keyword can be used to declare the variable as a global value. global var_1, var_2var_1, var_3 = "hello", "world" -- var_3 is local, var_1 is not.global this_is_global_assignment = "Hi!" Classes can also be prefixed with global to make them global classes. Alternatively, all CamelCase variables can be exported automatically using global ^, and all values can be globals using global *. do lets you manually create a scope, for when you need local variables. do x = 5print x -- nil Here we use do as an expression to create a closure. counter = do i = 0 -> i += 1 return iprint counter! -- 1print counter! -- 2 The local keyword can be used to define variables before they are assigned. local var_4if something var_4 = 1print var_4 -- works because `var_4` was set in this scope, not the `if` scope. The local keyword can also be used to shadow an existing variable. x = 10if false local x x = 12print x -- 10 Use local * to forward-declare all variables. Alternatively, use local ^ to forward-declare all CamelCase values. local *first = -> second!second = -> print datadata = {} 6.1 Import Import functions and variables from another module. import "mod" -- Is short for `const mod = require "mod"`.import "mod" as :func, :var -- Is short for `const {:func, :var} = require "mod"`. 6.2 With The with statement can be used to quickly call and assign values in an instance of a class or object. file = with File "lmsi15m.yue" -- `file` is the value of `set_encoding()`. \set_encoding "utf8"create_person = (name, relatives) -> with Person! .name = name \add_relative relative for relative in *relativesme = create_person "Ryan", ["sister", "sister", "brother", "dad", "mother"]with str = "Hello" -- assignment as expression! :D print "original: #{str}" print "upper: #{\upper!}" 6.3 Destructuring Destructuring can take arrays, tables, and nested tables and convert them into local variables. obj2 = numbers: [1, 2, 3, 4] properties: color: "green" height: 13.5{numbers: [first, second], properties: {:color}} = obj2print first, second, color -- 1 2 green first and second return [1] and [2] because they are as an array, but :color is like color: color so it sets itself to the color value. Destructuring can be used in place of import. {:max, :min, random: rand} = math -- rename math.random to rand Destructuring can be done anywhere assignment can be done. for [left, right] in *[ ["hello", "world"], ["egg", "head"]] print left, right Further ReadingFor complete YueScript documentation, visit the official YueScript website.